/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package vigas.calculos;

/**
 *
 * @author Gabriel
 */
public class VigaDuploApoio implements DiagramaEsforco{
    
    double E;			// módulo de elasticidade
    double I;			// momento de inércia
    double L;			// comprimento da viga
    int numPoints;		// número de pontos a serem calculados
    int i;

    // vetores para armazenamento de distância, cortante, momento e deflexão
    public double x[];		// distância da extremidade esquerda da viga
    public double v[];		// força cortante
    public double m[];		// momento
    public double y[];		// deflexão
    public double rr1;		// reação no apoio esquerdo
    public double rr2;		// reação no apoio direito

    public VigaDuploApoio(double E,double I,double L,int n)
    {
        this.L = L;
        this.E = E;
        this.I = I;
        
        this.numPoints=n;
        x = new double[n];
        inicializarVetores(n);
        for (i=0;i<numPoints;++i)
                x[i]=(double)i*L/((double)numPoints-1.);

    }

    private void inicializarVetores(int n){

        v = new double[n];          // força cortante
        m = new double[n];          // momento
        y = new double[n];

    }

    public void calcularEsforcosCargaDistribuida(double w1, double w2, double a, double b)
    {
        double d;
        double c;
        double W;

        inicializarVetores(numPoints);
        d = L-0.5*b-0.5*a;          // distância da extremidade direita ao centro da carga
        c = b-a;                    // comprimento da carga
        W = w1*c;
        rr1 = W * d / L;            // reação no apoio esquerdo
        rr2 = W/L*(a+0.5*c);	    // reação no apoio direito
        for (i=0;i<numPoints;++i)
        {
            if (x[i]<a)
            {
                v[i] = rr1;
                m[i] = -(rr1*x[i]);
                y[i] = 1/(48*E*I)*(8*rr1*(Math.pow(x[i],3)-L*L*x[i])
                        +W*x[i]*(8*d*d*d/L-2*b*c*c/L+c*c*c/L+2*c*c));
            }
            else
            {
                if (x[i]<b)
                {
                    v[i] = rr1-W*(x[i]-a)/c;
                    m[i] = -(rr1*x[i]-W*Math.pow(x[i]-a,2)/(2*c));
                    y[i] = 1/(48*E*I)*(8*rr1*(Math.pow(x[i],3)-L*L*x[i])
                            +W*x[i]*(8*d*d*d/L-2*b*c*c/L+c*c*c/L+2*c*c)
                            -2*W*Math.pow(x[i]-a,4)/c);
                }
                else
                {
                    v[i] = rr1-W;
                    m[i] = -(rr1*x[i]-W*(x[i]-0.5*a-0.5*b));
                    y[i] = 1/(48*E*I)*(8*rr1*(Math.pow(x[i],3)-L*L*x[i])
                            +W*x[i]*(8*d*d*d/L-2*b*c*c/L+c*c*c/L)
                            -8*W*Math.pow(x[i]-0.5*a-0.5*b,3)+W*(2*b*c*c-c*c*c));
                }
            }
        }

    }

    public void calcularEsforcosCargaConcentrada(double W, double a)
    {        
        double b=L-a;
        rr1 = W*b/L;
        rr2 = W*a/L;
        inicializarVetores(numPoints);

        for (i=0;i<numPoints;++i)
        {
            if (x[i]<a)
            {
                v[i] = W*b/L;
                m[i] = -(W*b/L*x[i]);
                y[i] = -W*b*x[i]/(6*E*I*L)*( 2*L*(L-x[i])-b*b-(L-x[i])*(L-x[i]) );
            }
            else if(x[i]<L)
            {
                v[i] = -W*a/L;
                m[i] = -(W*a/L*(L-x[i]));
                y[i] = -W*a*(L-x[i])/(6*E*I*L)*( 2*L*b-b*b-Math.pow(L-x[i],2) );
            }
            if (a>=L)
            {                
                v[i] = 0;
                m[i] = 0;
                y[i] = 0;
            }

        }
    }

    public void calcularEsforcosMomentoConcentrado(double mo, double a)
    {
        
        rr1 = -mo/L;
        rr2 = -rr1;
        inicializarVetores(numPoints);       
        
        // calcula o cortante, o momento e a deflexão até o ponto a
        for (i=0;i<numPoints;++i)
        {

            if (x[i]<a)
            {
                v[i] = rr1;
                m[i] = -(rr1*x[i]);
                y[i] = mo/(6*E*I)*( (6*a-3*a*a/L-2*L)*x[i]-Math.pow(x[i],3)/L );
            }
            else
            {
                v[i] = rr1;
                m[i] = -(rr1*x[i]+mo);
                y[i] = mo/(6*E*I)*( 3*a*a+3*x[i]*x[i]-Math.pow(x[i],3)/L -(2*L+3*a*a/L)*x[i] );
            }
        }
    }

     public double[] getM() {
        return m;
    }

    public double[] getV() {
        return v;
    }

}
